/*!{id:"uuStorage.js",ver:0.11,license:"MIT",author:"uupaa.js@gmail.com"}*/

var uu;
uu || (function(win, doc) {
uu = uumix(uufactory, {
	ver: _version(0.7),
	plugin: uuplugin,
	require: uurequire,
	like: uulike,
	type: uumix(uutype, {
		HASH: 0x001,
		NODE: 0x002,
		FAKEARRAY: 0x004,
		DATE: 0x008,
		NULL: 0x010,
		VOID: 0x020,
		UNDEFINED: 0x020,
		BOOLEAN: 0x040,
		FUNCTION: 0x080,
		NUMBER: 0x100,
		STRING: 0x200,
		ARRAY: 0x400,
		REGEXP: 0x800,
		CSS: 0x1000
	}),
	isNumber: uuisnumber,
	isString: uuisstring,
	isFunction: uuisfunction,
	arg: uuarg,
	mix: uumix,
	each: uueach,
	keys: uukeys,
	values: uuvalues,
	hash: uumix(uuhash, {
		has: uuhas,
		nth: uunth,
		size: uusize,
		clone: uuclone,
		indexOf: uuindexof
	}),
	array: uumix(uuarray, {
		has: uuhas,
		nth: uunth,
		size: uusize,
		sort: uusort,
		clean: uuclean,
		clone: uuclone,
		toHash: uutohash,
		unique: uuunique
	}),
	attr: uumix(uuattr, {
		get: uuattrget,
		set: uuattrset,
		getAll: uuattrgetall
	}),
	css: uumix(uucss, {
		get: uucssget,
		set: uucssset,
		opacity: uumix(uucssopacity, {
			get: uucssopacityget,// uu.css.opacity.get(node:Node):Number
			set: uucssopacityset
		})
	}),
	style: uumix(uustyle, {
		quick: uustylequick
	}),
	id: uuid,
	tag: uutag,
	query: uuquery,
	klass: uumix(uuklass, {
		has: uuklasshas,
		add: uuklassadd,
		sub: uuklasssub,
		toggle: uuklasstoggle
	}),
	Class: uumix(uuclass, {
		guid: uuclassguid,
		singleton: uuclasssingleton// uu.Class.singleton(className:String, proto:Hash = void)
	}),
	event: uumix(uuevent, {
		has: uueventhas,
		fire: uueventfire,
		stop: uueventstop,
		unbind: uueventunbind,
		attach: uueventattach,
		detach: uueventdetach
	}),
	node: uumix(uunode, {
		add: uunodeadd,
		has: uunodehas,
		root:       doc.documentElement || doc.html,
		bulk: uunodebulk,
		swap: uunodeswap,
		wrap: uunodewrap,
		clear: uunodeclear,
		clone: uunodebulk,
		remove: uunoderemove
	}),
	nodeid: uumix(uunodeid, {
		toNode: uunodeidtonode,
		remove: uunodeidremove
	}),
	fix: uufix,
	trim: uumix(uutrim, {
		tag: uutrimtag,
		url: uutrimurl,
		inner: uutriminner,
		quote: uutrimquote,
		bracket: uutrimbracket
	}),
	split: uumix(uusplit, {
		comma: uusplitcomma,
		toHash: uusplittohash
	}),
	format: uuformat,
	json: uumix(uujson, {
		decode: uujsondecode
	}),
	date: uudate,
	puff: uupuff,
	trace: uumix(uutrace, {
		clear: uutraceclear
	}),
	ready: uumix(uuready, {
		gone: {
			dom: 0,
			win: 0,
			audio: 0,
			video: 0,
			canvas: 0,
			storage: 0,
			blackout: 0
		}
	}),
	lazy: uumix(uulazy, {
		fire: uulazyfire
	}),
	js: uujs,
	win: {
		size: uuwinsize
	},
	nop:            function() {},
	dmz: {},
	guid: uuguid
});
MessagePump.prototype = {
	send: uumsgsend,
	post: uumsgpost,
	register: uumsgregister,
	unregister: uumsgunregister
};
uu.msg = new MessagePump();
Array.isArray || (Array.isArray = uuisarray);
uumix(Array.prototype, {
	map:            arraymap,
	some:           arraysome,
	every:          arrayevery,
	filter:         arrayfilter,
	forEach:        arrayforeach,
	indexOf:        arrayindexof,
	lastIndexOf:    arraylastindexof// lastIndexOf(search:Mix, fromIndex:Number = this.length):Number
}, 0, 0);
uumix(Array.prototype, {
	reduce:         arrayreduce,
	reduceRight:    arrayreduceright// reduceRight(evaluator:Function, initialValue:Mix = void):Mix
}, 0, 0);
uumix(Boolean.prototype, {
	toJSON:         numbertojson
}, 0, 0);
uumix(Date.prototype, {
	toISOString:    datetoisostring,// toISOString():String
	toJSON:         datetoisostring
}, 0, 0);
uumix(Number.prototype, {
	toJSON:         numbertojson
}, 0, 0);
uumix(String.prototype, {
	trim:           stringtrim,
	toJSON:         stringtojson
}, 0, 0);
uu.ver.gecko && win.HTMLElement && !win.HTMLElement.prototype.innerText &&
(function(proto) {
	proto.__defineGetter__("innerText", innertextgetter);
	proto.__defineSetter__("innerText", innertextsetter);
	proto.__defineGetter__("outerHTML", outerhtmlgetter);
	proto.__defineSetter__("outerHTML", outerhtmlsetter);
})(win.HTMLElement.prototype);
uu.ie       = uu.ver.ie;
uu.opera    = uu.ver.opera;
uu.gecko    = uu.ver.gecko;
uu.webkit   = uu.ver.webkit;
uu.config   = uuarg(win.xconfig, {
	aria:       false,
	debug:      false,
	right:      false,
	altcss: 0,
	storage: 0,
	visited:    false,
	baseDir: uutag("script").pop().src.replace(/[^\/]+$/, "")
});
doc.html || (doc.html = uutag("html")[0]);
doc.head || (doc.head = uutag("head")[0]);
win.xver && win.xver(uu.ver);
function uufactory(expression, arg1, arg2, arg3, arg4) {
	if (typeof expression === "string" && uuclass[expression]) {
		return new uuclass[expression](arg1, arg2, arg3, arg4);
	}
	return new uu.jam(expression, arg1, arg2, arg3, arg4);
}
function uuplugin() {
	return uukeys(uuplugin);
}
function uurequire(url) {
	var xhr, status = 400, ok = false;
	try {
		xhr = win.ActiveXObject  ? new ActiveXObject("Microsoft.XMLHTTP") :
			 win.XMLHttpRequest ? new XMLHttpRequest() : 0;
		xhr.open("GET", url, false);
		xhr.send(null);
		if (!xhr.status || (xhr.status >= 200 && xhr.status < 300)) {
			ok = true;
			status = xhr.status || 200;
		}
	} catch (err) {
		xhr = xhr || { responseText: "", responseXML: "", status: 400 };
	}
	return {
		ok:     ok,
		url:    url,
		xhr:    xhr,
		guid: uuguid(),
		status: status,
		isXMLContent: function() {
			return /xml/i.test(this.xhr.getResponseHeader("Content-Type") || "");
		}
	};
}
function uulike(lhs, rhs) {
	var type1 = uutype(lhs);
	if (type1 !== uutype(rhs)) {
		return false;
	}
	switch (type1) {
	case 0x080:   return false;
	case 0x008:       return uudate(lhs).ISO() ===
								 uudate(rhs).ISO();
	case 0x001:       return (uusize(lhs) === uusize(rhs) && uuhas(lhs, rhs));
	case 0x004:
	case 0x400:      return uuarray(lhs) + "" == uuarray(rhs);
	}
	return lhs === rhs;
}
function uutype(search, match) {
	var rv = uutype._TYPEOF[typeof search] ||
			 uutype._TYPEOF[Object.prototype.toString.call(search)] ||
			 (!search ? 0x010 : search.nodeType ? 0x002 :
			 "length" in search ? 0x004 : 0x001);
	return match ? !!(match & rv) : rv;
}
uutype._TYPEOF = {
	"undefined":        uutype.VOID,
	"[object Boolean]": 0x040,     "boolean":   0x040,
	"[object Number]":  0x100,      "number":    0x100,
	"[object String]":  0x200,      "string":    0x200,
	"[object Function]":0x080,    "function":  0x080,
	"[object RegExp]":  0x800,
	"[object Array]":   0x400,
	"[object Date]":    0x008,
	"[object CSSStyleDeclaration]":         0x1000,
	"[object ComputedCSSStyleDeclaration]": 0x1000
};
function uuisnumber(search) {
	return typeof search === "number";
}
function uuisstring(search) {
	return typeof search === "string";
}
function uuisarray(search) {
	return Object.prototype.toString.call(search) === "[object Array]";
}
function uuisdate(search) {
	return Object.prototype.toString.call(search) === "[object Date]";
}
function uuisfunction(search) {
	return Object.prototype.toString.call(search) === "[object Function]";
}
function uuarg(arg1, arg2, arg3) {
	return uumix(uumix({}, arg1 || {}), arg2, arg3, 0);
}
function uumix(base, flavor, aroma, override) {
	var i;
	if (override === void 0 || override) {
		for (i in flavor) {
			base[i] = flavor[i];
		}
	} else {
		for (i in flavor) {
			i in base || (base[i] = flavor[i]);
		}
	}
	return aroma ? uumix(base, aroma, 0, override) : base;
}
function uueach(source, callback) {
	if (Array.isArray(source)) {
		source.forEach(callback);
	} else {
		for (var i in source) {
			callback(source[i], i);
		}
	}
}
function uukeys(source, _enumValues) {
	var rv = [], ri = -1, i, iz;
	if (Array.isArray(source)) {
		for (i = 0, iz = source.length; i < iz; ++i) {
			i in source && (rv[++ri] = _enumValues ? source[i] : i);
		}
	} else {
		if (!_enumValues && Object.keys) {
			return Object.keys(source);
		}
		for (i in source) {
			if (source.hasOwnProperty(i)) {
				rv[++ri] = _enumValues ? source[i] : i;
			}
		}
	}
	return rv;
}
function uuvalues(source) {
	return uukeys(source, true);
}
function uuhash(key, value) {
	if (arguments.length === 1) {
		return key;
	}
	var rv = {};
	rv[key] = value;
	return rv;
}
_makeMapping("0123456789",       uuhash._dd2num = {}, uuhash._num2dd = {});
_makeMapping("0123456789abcdef", uuhash._hh2num = {}, uuhash._num2hh = {});
function uuarray(source) {
	var type = uutype(source), rv, i, iz;
	if (type === 0x004) {
		for (rv = [], i = 0, iz = source.length; i < iz; ++i) {
			rv[i] = source[i];
		}
		return rv;
	}
	return (type === 0x400) ? source : [source];
}
function uuhas(source, search) {
	if (source && search) {
		var i, iz;
		if (Array.isArray(source)) {
			search = uuarray(search);
			for (i = 0, iz = search.length; i < iz; ++i) {
				if (i in search && source.indexOf(search[i]) < 0) {
					return false;
				}
			}
			return true;
		}
		for (i in search) {
			if (!(i in source)) {
				return false;
			}
			if (source[i] !== search[i]
				&& _jsoninspect(source[i]) !== _jsoninspect(search[i])) {
				return false;
			}
		}
		return true;
	}
	return false;
}
function uunth(source, index) {
	var i, j = 0;
	if (Array.isArray(source)) {
		if (i in source) {
			return [i, source[i]];
		}
	} else {
		for (i in source) {
			if (j++ === index) {
				return [i, source[i]];
			}
		}
	}
	return [void 0, void 0];
}
function uusize(source) {
	return Array.isArray(source) ? source.length : uukeys(source).length;
}
function uuclone(source) {
	return Array.isArray(source) ? source.concat() : uumix({}, source);
}
function uuindexof(source, search) {
	for (var i in source) {
		if (source.hasOwnProperty(i) && source[i] === search) {
			return i;
		}
	}
	return void 0;
}
function uusort(source, method) {
	function _numericsort(a, b) {
		return a - b;
	}
	if (Array.isArray(source)) {
		switch (method || "0-9") {
		case "0-9": source.sort(_numericsort); break;
		case "9-0": source.sort(_numericsort).reverse(); break;
		case "A-Z": source.sort(); break;
		case "Z-A": source.sort().reverse(); break;
		default:    source.sort(method);
		}
	}
	return source;
}
function uuclean(source) {
	if (Array.isArray(source)) {
		var rv = [], i = 0, iz = source.length;
		for (; i < iz; ++i) {
			if (i in source) {
				if (source[i] != null) {
					rv.push(source[i]);
				}
			}
		}
		return rv;
	}
	return source;
}
function uuunique(source, literalOnly) {
	literalOnly = literalOnly ? true : false;
	if (Array.isArray(source)) {
		var rv = [], ri = -1, v, i = 0, j, iz = source.length,
			found,
			unique = {};
		for (; i < iz; ++i) {
			v = source[i];
			if (v != null) {
				if (literalOnly) {
					unique[v] || (unique[v] = 1, rv[++ri] = v);
				} else {
					for (found = 0, j = i - 1; !found && j >= 0; --j) {
						found = (v === source[j]);
					}
					!found && (rv[++ri] = v);
				}
			}
		}
		return rv;
	}
	return source;
}
function uutohash(key, value, toNumber) {
	var rv = {}, i = 0, iz = key.length, val;
	if (Array.isArray(value)) {
		for (; i < iz; ++i) {
			rv[key[i]] = toNumber ? +(value[i]) : value[i];
		}
	} else {
		val = toNumber ? +(value) : value;
		for (; i < iz; ++i) {
			rv[key[i]] = val;
		}
	}
	return rv;
}
function uuattr(node, key, value) {
	return (value === void 0 && uuisstring(key) ? uuattrget
												: uuattrset)(node, key, value);
}
uuattr._HASH = uusplittohash(
	uu.ver.ie67 ? "for,htmlFor,className,class"
				: ("class,className,for,htmlFor,colspan,colSpan," +
				 "accesskey,accessKey,rowspan,rowSpan,tabindex,tabIndex")
);
function uuattrget(node, attrs) {
	var rv = {}, ary = attrs.split(","), v, w, i = 0, iz = ary.length,
		HASH = uuattr._HASH;
	for (; i < iz; ++i) {
		v = ary[i];
		w = HASH[v] || v;
		if (uu.ie) {
			if (uu.ver.ie89 || v === "href" || v === "src") {
				rv[v] = node.getAttribute(v, 2) || "";
			} else {
				rv[v] = node[w] || "";
			}
		} else {
			rv[v] = node.getAttribute(w) || "";
		}
	}
	return (ary.length === 1) ? rv[ary[0]] : rv;
}
function uuattrset(node, key, value) {
	var hash, i, HASH = uuattr._HASH;
	uuisstring(key) ? (hash = {}, hash[key] = value) : (hash = key);
	for (i in hash) {
		node.setAttribute(HASH[i] || i, hash[i]);
	}
	return node;
}
function uuattrgetall(node, filter) {
	filter = filter ? true : false;
	var rv = {}, ary = node.attributes, v, w, i = -1;
	while ( (v = ary[++i]) ) {
		w = v.name;
		if (!filter) {
			rv[w] = v.value;
		} else if (v.specified && w !== "style" && w.indexOf("uu")) {
			rv[w] = v.value;
		}
	}
	return rv;
}
function uucss(node, key, value) {
	return (value === void 0 && uuisstring(key) ? uucssget
												: uucssset)(node, key, value);
}
function uucssget(node, styles) {
	var rv = {}, ary = styles.split(","), v, i = -1,
		ns = uustyle(node), fixdb = uufix._db;
	while ( (v = ary[++i]) ) {
		rv[v] = ns[fixdb[v] || v] || "";
	}
	return (ary.length === 1) ? rv[ary[0]] : rv;
}
function uucssset(node, key, value) {
	var hash = uuhash(key, value),
		ns = node.style, p, v, i, n,
		fixdb = uufix._db, hook = uucssset._hook;
	for (i in hash) {
		v = hash[i];
		p = fixdb[i] || i;
		if (typeof v === "string") {
			ns[p] = v;
		} else {
			n = hook[p];
			if (n === 2) {
				uucssopacityset(node, v);
			} else {
				ns[p] = n ? v : (v + "px");
			}
		}
	}
	return node;
}
uucssset._hook = { opacity: 2, lineHeight: 1, fontWeight: 1,
				 fontSizeAdjust: 1, zIndex: 1, zoom: 1 };
function uucssopacity(node, opacity, isRelativeValue) {
	return (opacity === void 0 ? uucssopacityget
							 : uucssopacityset)(node, opacity, isRelativeValue);
}
function uucssopacityget(node) {
	if (uu.ie) {
		var v = node.uucssopacity;
		return v === void 0 ? 1 : (v - 1);
	}
	return parseFloat(node.style.opacity ||
					 win.getComputedStyle(node, null).opacity);
}
function uucssopacityset(node, opacity, isRelativeValue) {
	var ns;
	if (uu.ver.ie678) {
		ns = node.style;
		if (node.uucssopacity === void 0) {
			if (uu.ver.ie67) {
				if ((node.currentStyle || {}).width === "auto") {
					ns.zoom = 1;
				}
			}
		}
	}
	isRelativeValue && (opacity += uucssopacityget(node));
	opacity = (opacity > 0.999) ? 1
			: (opacity < 0.001) ? 0 : opacity;
	node.style.opacity = opacity;
	if (uu.ver.ie678) {
		node.uucssopacity = opacity + 1;
		ns.visibility = opacity ? "" : "hidden";
		ns.filter = ((opacity > 0 && opacity < 1)
				 ? "alpha(opacity=" + (opacity * 100) + ") " : "")
				 + ns.filter.replace(uucssopacityset._alpha, "");
	}
	return node;
}
uucssopacityset._alpha = /^alpha\([^\x29]+\) ?/;
function uustyle(node, mode) {
	if (uu.ver.ie678) {
		if (mode === 4) {
			return node.currentStyle;
		}
		if (!node.currentStyle) {
			return {};
		}
		var rv = {},
			ns = node.style,
			cs = node.currentStyle,
			rs = node.runtimeStyle,
			box = uustyle._HASH.box, UNITS = uustyle._UNITS,
			RECTANGLE = uustyle._RECTANGLE,
			em, rect, ut, v, w, x, i = -1, j = -1, m1, m2,
			ary = !mode ? uustyle._HASH.full
						: (mode === 1) ? uustyle._HASH.more
									 : 0,
			stock = { "0px": "0px", "1px": "1px", "2px": "2px", "5px": "5px",
					 thin: "1px", medium: "3px", thick: uustyle._THICK_FIX };
		if (ary) {
			while ( (w = ary[++j]) ) {
				rv[w] = cs[w];
			}
		}
		em = parseFloat(cs.fontSize) *
					(uustyle._UNIT_PT.test(cs.fontSize) ? 4 / 3 : 1);
		rect = node.getBoundingClientRect();
		while ( (w = box[++i]) ) {
			v = cs[w];
			if (!(v in stock)) {
				x = v;
				switch (ut = UNITS[v.slice(-1)]) {
				case 1: x = parseFloat(v) * em; break;
				case 2: x = parseFloat(v) * 4 / 3; break;
				case 3: m1 = ns.left, m2 = rs.left;
						rs.left = cs.left, ns.left = v;
						x = ns.pixelLeft, ns.left = m1, rs.left = m2;
				}
				stock[v] = ut ? x + "px" : x;
			}
			rv[w] = stock[v];
		}
		for (w in RECTANGLE) {
			v = cs[w];
			switch (ut = UNITS[v.slice(-1)]) {
			case 1: v = parseFloat(v) * em; break;
			case 2: v = parseFloat(v) * 4 / 3; break;
			case 3:
				switch (RECTANGLE[w]) {
				case 1: v = node.offsetTop; break;
				case 2: v = node.offsetLeft; break;
				case 3: v = (node.offsetWidth  || rect.right - rect.left)
						 - parseInt(rv.borderLeftWidth)
						 - parseInt(rv.borderRightWidth)
						 - parseInt(rv.paddingLeft)
						 - parseInt(rv.paddingRight);
						v = v > 0 ? v : 0;
						break;
				case 4: v = (node.offsetHeight || rect.bottom - rect.top)
						 - parseInt(rv.borderTopWidth)
						 - parseInt(rv.borderBottomWidth)
						 - parseInt(rv.paddingTop)
						 - parseInt(rv.paddingBottom);
						v = v > 0 ? v : 0;
				}
			}
			rv[w] = ut ? v + "px" : v;
		}
		rv.fontSize = em + "px";
		rv.cssFloat = cs.styleFloat;
		return rv;
	}
	return win.getComputedStyle(node, null);
}
uustyle._HASH = uu.ver.ie678 ? _builduustylehash() : {};
uustyle._UNITS = { m: 1, t: 2, "%": 3, o: 3 };
uustyle._UNIT_PT = /pt$/;
uustyle._THICK_FIX = uu.ver.ie89 ? "5px" : "6px";
uustyle._RECTANGLE = { top: 1, left: 2, width: 3, height: 4 };
function uustylequick(node) {
	return uustyle(node, 4);
}
function _builduustylehash() {
	var rv = { full: [], more: [], box: [] },
		ary = [" "], i, w, trim = /^\s+|\s+$/g,
		cs = doc.html.currentStyle;
	for (i in cs) {
		ary.push(i);
	}
	ary.sort();
	w = ary.join(" ").replace(/ (?:accelerator|behavior|hasLayout|zoom)/g, "");
	rv.full = w.replace(trim, "").split(" ");
	rv.more = w.replace(/ (?:lay\w+|rub\w+|text\w+|pageB\w+|ms\w+|scr\w+)/g, "").
		replace(/ (?:blockDirection|orphans|quotes|widows|filter|styleFloat)/g, "").
		replace(/ (?:imeMode|writingMode|unicodeBidi|emptyCells|tableLayout)/g, "").
		replace(/ (?:border(?:Color|Style|Width)|margin|padding|outline) /g, " ").
		replace(/ (border\w+Width|margin\w+|padding\w+)/g, function(_, m) {
		 return rv.box.push(m), _;
		}).replace(trim, "").concat(" textAlign textOverflow textIndent").
		split(" ").sort();
	return rv;
}
function uuklasshas(node, classNames) {
	var m, ary, cn = node.className;
	if (!classNames || !cn) {
		return false;
	}
	if (classNames.indexOf(" ") < 0) {
		return (" " + cn + " ").indexOf(" " + classNames + " ") >= 0;
	}
	ary = uusplit(classNames);
	m = cn.match(_classNameMatcher(ary));
	return m && m.length >= ary.length;
}
function uuklassadd(node, classNames) {
	node.className += " " + classNames;
	return node;
}
function uuklasssub(node, classNames) {
	node.className = uutriminner(
			node.className.replace(_classNameMatcher(uusplit(classNames)), ""));
	return node;
}
function uuklasstoggle(node, classNames) {
	(uuklasshas(node, classNames) ? uuklasssub : uuklassadd)(node, classNames);
	return node;
}
function uuclass(className, proto) {
	var ary = className.split(/\s*[\x3a-\x40]\s*/), tmp, i,
		Class = ary[0], Super = ary[1] || "";
	uuclass[Class] = function uuClass() {
		var lv3 = this,
			lv2 = lv3.superClass || 0,
			lv1 = lv2 ? lv2.superClass : 0;
		uuclassguid(lv3);
		lv3.msgbox || (lv3.msgbox = uu.nop);
		uu.msg.register(lv3);
		lv1 && lv1.init && lv1.init.apply(lv3, arguments);
		lv2 && lv2.init && lv2.init.apply(lv3, arguments);
			 lv3.init && lv3.init.apply(lv3, arguments);
		lv3["~fin"] = lv3.fin || uu.nop;
		if (lv3.fin) {
			uu.event.attach(win, "unload", function() {
				lv3.fin && lv3.fin();
			});
		}
		lv3.fin = function wrapper() {
			lv3["~fin"]();
			lv2 && lv2.fin && lv2.fin.call(lv3);
			lv1 && lv1.fin && lv1.fin.call(lv3);
			for (var i in lv3) {
				lv3[i] = null;
			}
		};
	};
	uuclass[Class].prototype = proto || {};
	if (Super) {
		tmp = function() {};
		tmp.prototype = uu.Class[Super].prototype;
		uuclass[Class].prototype = new tmp;
		for (i in proto) {
			uuclass[Class].prototype[i] = proto[i];
		}
		uuclass[Class].prototype.constructor = uuclass[Class];
		uuclass[Class].prototype.superClass = uu.Class[Super].prototype;
		uuclass[Class].prototype.superMethod = superMethod;
	}
	function superMethod(from,
						 method
						 ) {
		var obj = this.superClass;
		if (from === obj[method] || superMethod.caller === obj[method]) {
			obj = obj.superClass;
		}
		return obj[method].apply(this, uu.array(arguments).slice(2));
	}
}
function uuclassguid(instance) {
	return instance.uuguid || (instance.uuguid = uu.guid());
}
function uuclasssingleton(className, proto) {
	uuclass[className] = function() {
		var that = this, arg = arguments, self = arg.callee;
		if (self.instance) {
			that.stable && that.stable.apply(that, arg);
		} else {
			uuclassguid(that);
			that.init && that.init.apply(that, arg);
			that.fin  && uu.event.attach(win, "unload", function() {
				that.fin();
			});
			that.msgbox || (that.msgbox = uu.nop);
			uu.msg.register(that);
		}
		return self.instance || (self.instance = that);
	};
	uuclass[className].prototype = proto || {};
}
function MessagePump() {
	this._addressMap = {};
	this._broadcast = [];
}
function uumsgsend(address, message, param) {
	var rv = [], ri = -1, to, obj, i = -1,
		ary = address ? uu.array(address) : this._broadcast;
	while ( (to = ary[++i]) ) {
		obj = this._addressMap[to.uuguid || to || 0];
		obj && (rv[++ri] = obj.msgbox(message, param));
	}
	return rv;
}
function uumsgpost(address, message, param) {
	var that = this;
	setTimeout(function() {
		that.send(address ? uu.array(address) : that._broadcast, message, param);
	}, 0);
}
function uumsgregister(instance) {
	this._addressMap[uuclassguid(instance)] = instance;
	this._broadcast = uu.keys(this._addressMap);
}
function uumsgunregister(instance) {
	delete this.db[uuclassguid(instance)];
	this._broadcast = uu.keys(this._addressMap);
}
function uuevent(node, namespaceAndEventTypes, evaluator, detach) {
	function _uueventclosure(evt, fromCustomEvent) {
		evt = evt || win.event;
		if (!fromCustomEvent && !evt.code) {
			var src = evt.srcElement || evt.target,
				iebody;
			src = (uu.webkit && src.nodeType === 3) ? src.parentNode : src;
			evt.code = (EVENT_CODE[evt.type] || 0) & 255;
			evt.node = node;
			evt.src = src;
			if (uu.ie) {
				iebody = uu.quirks ? doc.body : uu.node.root;
				evt.px = evt.clientX + iebody.scrollLeft;
				evt.py = evt.clientY + iebody.scrollTop;
			} else {
				evt.px = evt.pageX;
				evt.py = evt.pageY;
			}
			evt.ox = evt.offsetX || evt.layerX || 0;
			evt.oy = evt.offsetY || evt.layerY || 0;
		}
		isInstance ? handler.call(evaluator, evt, node, src)
				 : evaluator(evt, node, src);
	}
	var types = node.uueventtypes || (node.uueventfn = {},
									 node.uueventtypes = ","),
		nstype = namespaceAndEventTypes.split(","), v, i = -1, m,
		type, capt, closure, handler,
		isInstance = false, EVENT_CODE = uuevent._CODE;
	if (detach) {
		closure = evaluator.uueventclosure || evaluator;
	} else {
		handler = uuisfunction(evaluator)
				? evaluator
				: (isInstance = true, evaluator.handleEvent);
		closure = evaluator.uueventclosure = _uueventclosure;
	}
	while ( (v = nstype[++i]) ) {
		m = uuevent._PARSE.exec(v);
		if (m) {
			type = m[2];
			capt = m[3];
			if (uu.ie) {
				if (capt && type === "mousemove") {
					uuevent(node, "losecapture", closure, detach);
				}
			}
			if (types.indexOf("," + v + ",") >= 0) {
				if (detach) {
					if (uu.ie) {
						if (type === "losecapture" && node.releaseCapture) {
							node.releaseCapture();
						}
					}
					node.uueventtypes =
							node.uueventtypes.replace("," + v + ",", ",");
					node.uueventfn[v] = void 0;
					uueventdetach(node, type, closure, capt);
				}
			} else if (!detach) {
				uu.ie && type === "losecapture"
					 && node.setCapture
					 && node.setCapture();
				node.uueventtypes += v + ",";
				node.uueventfn[v] = closure;
				uueventattach(node, type, closure, capt);
			}
		}
	}
	return node;
}
uuevent._PARSE = /^(?:(\w+)\.)?(\w+)(\+)?$/;
uuevent._LIST = ("mousedown,mouseup,mousemove,mousewheel,click,dblclick," +
	"keydown,keypress,keyup,change,submit,focus,blur,contextmenu").split(",");
uuevent._CODE = {
	mousedown: 1, mouseup: 2, mousemove: 3, mousewheel: 4, click: 5,
	dblclick: 6, keydown: 7, keypress: 8, keyup: 9, mouseenter: 10,
	mouseleave: 11, mouseover: 12, mouseout: 13, contextmenu: 14,
	focus: 15, blur: 16, resize: 17,
	losecapture: 0x102, DOMMouseScroll: 0x104
};
function uueventhas(node, namespaceAndEventTypes) {
	return (node.uueventtypes || "").indexOf("," + namespaceAndEventTypes + ",") >= 0;
}
function uueventfire(node, eventType, param) {
	if (uu.event.has(node, eventType)) {
		node.uueventfn[eventType].call(node, {
			stopPropagation: uu.nop,
			preventDefault: uu.nop,
			node:   node,
			name:   eventType,
			code: 0,
			src:    node,
			rel:    node,
			px: 0,
			py: 0,
			ox: 0,
			oy: 0,
			type:   eventType,
			param:  param
		}, true);
	}
	return node;
}
function uueventstop(eventObject) {
	uu.ie ? (eventObject.cancelBubble = true) : eventObject.stopPropagation();
	uu.ie ? (eventObject.returnValue = false) : eventObject.preventDefault();
	return eventObject;
}
function uueventunbind(node, namespaceAndEventTypes) {
	function _eachnamespace(w) {
		!w.indexOf(ns) && uuevent(node, w, node.uueventfn[w], true);
	}
	var types = node.uueventtypes, nstype, v, i = -1, ns;
	if (types && types.length > 1) {
		if (namespaceAndEventTypes) {
			nstype = uusplitcomma(namespaceAndEventTypes);
			while ( (v = nstype[++i]) ) {
				if (v.lastIndexOf(".*") > 1) {
					 ns = v.slice(0, -1);
					 uusplitcomma(types).forEach(_eachnamespace);
				} else {
					 (types.indexOf("," + v + ",") >= 0) &&
						 uuevent(node, v, node.uueventfn[v], true);
				}
			 }
		} else {
			nstype = uusplitcomma(types);
			while ( (v = nstype[++i]) ) {
				uuevent(node, v, node.uueventfn[v], true);
			}
		}
	}
	return node;
}
function uueventattach(node, eventType, evaluator, capture) {
	eventType = uueventattach._FIX[eventType] || eventType;
	if (node.addEventListener) {
		node.addEventListener(eventType, evaluator, !!(capture || 0));
	} else {
		node.attachEvent("on" + eventType, evaluator);
	}
}
uueventattach._FIX = uu.gecko ? { mousewheel: "DOMMouseScroll" } :
					 uu.opera ? { contextmenu: "mousedown" } : {};
function uueventdetach(node, eventType, evaluator, capture) {
	eventType = uueventattach._FIX[eventType] || eventType;
	if (node.removeEventListener) {
		node.removeEventListener(eventType, evaluator, !!(capture || 0));
	} else {
		node.detachEvent("on" + eventType, evaluator);
	}
}
function uuready(evaluator, order) {
	if (evaluator !== void 0 && !uuready.gone.blackout) {
		uuready.gone.dom ? evaluator(uu)
						 : uulazy("boot", evaluator, order || 0);
	}
}
function uunode(tagName, attr) {
	var rv = doc.createElement(tagName || "div");
	return attr === void 0 ? rv : uumix(rv, attr);
}
function uunodeadd(source, context, position) {
	context = context || doc.body;
	var node = !source ? doc.createElement("div")
			 : source.nodeType ? source
			 : !source.indexOf("<") ? uunodebulk(source)
			 : doc.createElement(source),
		parentNode = context.parentNode,
		rv = (node.nodeType === 11) ? node.firstChild : node;
	switch (position || 6) {
	case 1: parentNode.insertBefore(node, parentNode.firstChild); break;
	case 2: parentNode.insertBefore(node, context); break;
	case 3: parentNode.insertBefore(node, context.nextSibling); break;
	case 4: parentNode.appendChild(node); break;
	case 5: context.insertBefore(node, context.firstChild); break;
	case 6: context.appendChild(node);
	}
	return rv;
}
function uunodeid(node) {
	if (!node.uuguid) {
		uunodeid._db[node.uuguid = ++uunodeid._num] = node;
	}
	return node.uuguid;
}
uunodeid._num = 0;
uunodeid._db = {};
function uunodeidtonode(nodeid) {
	return uunodeid._db[nodeid];
}
function uunodeidremove(node) {
	node.uuguid && (uunodeid._db[node.uuguid] = null, node.uuguid = null);
	return node;
}
function uunodehas(node, context) {
	for (var c = node; c && c !== context;) {
		c = c.parentNode;
	}
	return node !== context && c === context;
}
function uunodebulk(source) {
	var rv = doc.createDocumentFragment(),
		placeholder = uunode();
	placeholder.innerHTML = uuisstring(source) ? source
											 : source.outerHTML;
	while (placeholder.firstChild) {
		rv.appendChild(placeholder.removeChild(placeholder.firstChild));
	}
	return rv;
}
function uunodeswap(swapin, swapout) {
	return swapout.parentNode.replaceChild(swapin, swapout);
}
function uunodewrap(innerNode, outerNode) {
	return outerNode.appendChild(uunodeswap(outerNode, innerNode));
}
function uunodeclear(context) {
	var rv = uu.tag("*", context), v, i = -1;
	while ( (v = rv[++i]) ) {
		uunodeidremove(v);
		uueventunbind(v);
	}
	rv = [];
	while (context.firstChild) {
		context.removeChild(context.firstChild);
	}
	return context;
}
function uunoderemove(node) {
	if (node && node.parentNode) {
		uunodeidremove(node);
		return node.parentNode.removeChild(node);
	}
	return node;
}
function uuquery(expression, context) {
	if (context && doc.querySelectorAll && context.nodeType
				&& !uuquery._NGWORD.test(expression)) {
		try {
			var rv = [],
				nodeList = (context || doc).querySelectorAll(expression),
				i = 0, iz = nodeList.length;
			for (; i < iz; ++i) {
				rv[i] = nodeList[i];
			}
			return rv;
		} catch(err) {}
	}
	return uuquery.selectorAll(expression, context || doc);
}
uuquery._NGWORD = /(:(a|b|co|dig|first-l|li|mom|ne|p|sc|t|v))|!=|\/=|<=|>=|&=|x7b/;
function uuid(expression, context) {
	return (context || doc).getElementById(expression);
}
function uutag(expression, context) {
	var nodeList = (context || doc).getElementsByTagName(expression),
		rv = [], ri = -1, v, i = 0, iz = nodeList.length;
	if (uu.ie && expression === "*") {
		for (; i < iz; ++i) {
			(v = nodeList[i]).nodeType === 1 && (rv[++ri] = v);
		}
	} else {
		for (; i < iz; ++i) {
			rv[i] = nodeList[i];
		}
	}
	return rv;
}
uutag.HTML4 = ("a,b,br,dd,div,dl,dt,h1,h2,h3,h4,h5,h6,i,img,iframe," +
			 "input,li,ol,option,p,pre,select,span,table,tbody,tr," +
			 "td,th,tfoot,textarea,u,ul").split(",");
uutag.HTML5 = ("abbr,article,aside,audio,bb,canvas,datagrid,datalist," +
			 "details,dialog,eventsource,figure,footer,header,hgroup," +
			 "mark,menu,meter,nav,output,progress,section,time,video").split(",");
function uuklass(expression, context) {
	context = context || doc;
	var rv = [], ri = -1, i = 0, iz, v,
		nodeList, match, cn, nz, rex, name;
	if (context.getElementsByClassName) {
		nodeList = context.getElementsByClassName(expression);
		for (iz = nodeList.length; i < iz; ++i) {
			rv[i] = nodeList[i];
		}
	} else {
		nodeList = context.getElementsByTagName("*");
		name = uusplit(expression);
		name.length > 1 && (name = uuunique(name, 1));
		rex = _classNameMatcher(name);
		for (nz = name.length, iz = nodeList.length; i < iz; ++i) {
			v = nodeList[i];
			cn = v.className;
			if (cn) {
				match = cn.match(rex);
				(match && match.length >= nz) && (rv[++ri] = v);
			}
		}
	}
	return rv;
}
function uufix(source) {
	return uufix._db[source] || source;
}
uufix._db = {};
function uutrim(source) {
	return source.replace(uutrim._TRIM, "");
}
uutrim._TAG     = /<\/?[^>]+>/g;
uutrim._TRIM    = /^\s+|\s+$/g;
uutrim._QUOTE   = /^\s*["']?|["']?\s*$/g;
uutrim._SPACES  = /\s\s+/g;
uutrim._BRACKET = /^\s*[\(\[\{<]?|[>\}\]\)]?\s*$/g;
function uutrimtag(source) {
	return source.replace(uutrim._TRIM, "").
				 replace(uutrim._TAG, "").
				 replace(uutrim._SPACES, " ");
}
function uutrimurl(source) {
	return (!source.indexOf("url(") && source.indexOf(")") === source.length - 1) ?
			source.slice(4, -1).replace(uutrim._QUOTE, "") : source;
}
function uutriminner(source) {
	return source.replace(uutrim._TRIM, "").replace(uutrim._SPACES, " ");
}
function uutrimquote(source) {
	return source.replace(uutrim._QUOTE, "");
}
function uutrimbracket(source) {
	return source.replace(uutrim._BRACKET, "");
}
function uusplit(source) {
	return source.replace(uutrim._SPACES, " ").
				 replace(uutrim._TRIM, "").split(" ");
}
uusplit._MANY_COMMAS           = /,,+/g;
uusplit._TRIM_SPACE_AND_COMMAS = /^[ ,]+|[ ,]+$/g;
function uusplitcomma(source) {
	return source.replace(uusplit._MANY_COMMAS, ",").
				 replace(uusplit._TRIM_SPACE_AND_COMMAS, "").split(",");
}
function uusplittohash(source, splitter, toNumber) {
	var rv = {}, ary = source.split(splitter || ","), i = 0, iz = ary.length,
		num = toNumber ? true : false;
	for (; i < iz; i += 2) {
		rv[ary[i]] = num ? +(ary[i + 1]) : ary[i + 1];
	}
	return rv;
}
function uuformat(format) {
	var i = 0, args = arguments;
	return format.replace(uuformat._PLACEHOLDER, function() {
		return args[++i];
	});
}
uuformat._PLACEHOLDER = /\?/g;
function uupuff(source) {
	alert(_jsoninspect(source));
}
function uutrace(titleOrSource, source) {
	var output = uuid("trace"), json, title = "";
	if (output) {
		if (source !== void 0) {
			title = titleOrSource;
			json = _jsoninspect(source);
		} else {
			json = _jsoninspect(titleOrSource);
		}
		if (output.tagName.toLowerCase() === "textarea") {
			output.value += title + json;
		} else {
			output.innerHTML += "<p>" + title + json + "</p>";
		}
	}
}
function uutraceclear() {
	var output = uuid("trace");
	if (output) {
		if (output.tagName.toLowerCase() === "textarea") {
			output.value = "";
		} else {
			output.innerHTML = "";
		}
	}
}
function uujson(source, useNativeJSON, callback) {
	return useNativeJSON && win.JSON ? win.JSON.stringify(source) || ""
									 : _jsoninspect(source, callback);
}
function uujsondecode(jsonString, useNativeJSON) {
	var str = uutrim(jsonString);
	if (useNativeJSON && win.JSON) {
		return win.JSON.parse(str);
	}
	return uujsondecode._NGWORD.test(str.replace(uujsondecode._UNESCAPE, ""))
				? false : uujs("return " + str + ";");
}
uujsondecode._NGWORD = /[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/;
uujsondecode._UNESCAPE = /"(\\.|[^"\\])*"/g;
function _str2json(str, addQuote) {
	function _swap(m) {
		return _str2json._SWAP[m];
	}
	function _ucs2(str, c) {
		c = str.charCodeAt(0);
		return "\\u" + uuhash._num2hh[(c >> 8) & 255] +
					 uuhash._num2hh[ c       & 255];
	}
	var rv = str.replace(_str2json._ESCAPE, _swap).
				 replace(_str2json._ENCODE, _ucs2);
	return addQuote ? '"' + rv + '"' : rv;
}
_str2json._SWAP = uusplittohash('",\\",\b,\\b,\f,\\f,\n,\\n,\r,\\r,\t,\\t,\\,\\\\');
_str2json._ESCAPE = /(?:\"|\\[bfnrt\\])/g;
_str2json._ENCODE = /[\x00-\x1F\u0080-\uFFEE]/g;
function _jsoninspect(mix, fn) {
	var ary, type = uutype(mix), w, ai = -1, i, iz;
	if (mix === win) {
		return '"window"';
	}
	switch (type) {
	case 0x1000:
	case 0x001:       ary = []; break;
	case 0x002:       return '"uuguid":' + uunodeid(mix);
	case 0x010:       return "null";
	case uutype.VOID:       return "undefined";
	case 0x008:       return uudate(mix).ISO();
	case 0x040:
	case 0x080:
	case 0x100:     return mix.toString();
	case 0x200:     return _str2json(mix, 1);
	case 0x400:
	case 0x004:
		for (ary = [], i = 0, iz = mix.length; i < iz; ++i) {
			ary[++ai] = _jsoninspect(mix[i], fn);
		}
		return "[" + ary + "]";
	default:
		return fn ? (fn(mix) || "") : "";
	}
	if (type === 0x1000) {
		w = uu.webkit;
		for (i in mix) {
			if (typeof mix[i] === "string" && (w || i != (+i + ""))) {
				w && (i = mix.item(i));
				ary[++ai] = '"' + i + '":' + _str2json(mix[i], 1);
			}
		}
	} else {
		for (i in mix) {
			ary[++ai] = _str2json(i, 1) + ":" + _jsoninspect(mix[i], fn);
		}
	}
	return "{" + ary + "}";
}
function uudate(source) {
	return source === void 0  ? _date2hash(new Date())
		 : uuisdate(source)   ? _date2hash(source)
		 : uuisnumber(source) ? _date2hash(new Date(source))
		 : source.GMT         ? uuclone(source)
		 : _date2hash(_str2date(source) || new Date(source));
}
function _date2hash(date) {
	return {
		Y:      date.getUTCFullYear(),      M:      date.getUTCMonth() + 1,
		D:      date.getUTCDate(),          h:      date.getUTCHours(),
		m:      date.getUTCMinutes(),       s:      date.getUTCSeconds(),
		ms:     date.getUTCMilliseconds(),  time:   date.getTime(),
		ISO:    datehashiso,
		RFC:    datehashrfc,
		GMT:    datehashrfc
	};
}
function _str2date(str) {
	function _toDate(_, dayOfWeek, day, month) {
		return dayOfWeek + " " + month + " " + day;
	}
	var m = _str2date._PARSE.exec(str);
	if (m) {
		return new Date(Date.UTC(+m[1], +m[2] - 1, +m[3],
								 +m[4], +m[5], +m[6], +m[7]));
	}
	if (uu.ie && str.indexOf("GMT") > 0) {
		str = str.replace(/GMT/, "UTC");
	}
	return new Date(str.replace(",", "").
						replace(_str2date._DATE, _toDate));
}
_str2date._PARSE = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.(\d*))?Z$/;
_str2date._DATE = /^([\w]+) (\w+) (\w+)/;
function datehashiso() {
	var padZero = (this.ms < 10) ? "00" : (this.ms < 100) ? "0" : "",
		dd = uuhash._num2dd;
	return uuformat("?-?-?T?:?:?.?Z", this.Y, dd[this.M], dd[this.D],
									 dd[this.h], dd[this.m], dd[this.s],
									 padZero + this.ms);
}
function datehashrfc() {
	var rv = (new Date(this.time)).toUTCString();
	if (uu.ie && rv.indexOf("UTC") > 0) {
		rv = rv.replace(/UTC/, "GMT");
		(rv.length < 29) && (rv = rv.replace(/, /, ", 0"));
	}
	return rv;
}
function uujs(javascriptExpression) {
	return (new Function(javascriptExpression))();
}
function uuwinsize() {
	if (uu.ie) {
		var iebody = uu.quirks ? doc.body : uu.node.root;
		return { innerWidth:  iebody.clientWidth,
				 innerHeight: iebody.clientHeight,
				 pageXOffset: iebody.scrollLeft,
				 pageYOffset: iebody.scrollTop };
	}
	return { innerWidth:  win.innerWidth,
			 innerHeight: win.innerHeight,
			 pageXOffset: win.pageXOffset,
			 pageYOffset: win.pageYOffset };
}
function uuguid() {
	return ++uuguid._num;
}
uuguid._num = 0;
function uulazy(id, evaluator, order) {
	uulazy._db[id] || (uulazy._db[id] = [[], [], []]);
	uulazy._db[id][order || 0].push(evaluator);
}
uulazy._db = {};
function uulazyfire(id) {
	if (uulazy._db[id]) {
		var fn, i = -1, db = uulazy._db[id],
			ary = db[2].concat(db[1], db[0]);
		uulazy._db[id] = null;
		while ( (fn = ary[++i]) ) {
			fn(uu);
		}
	}
}
function arrayindexof(search, fromIndex) {
	var iz = this.length, i = fromIndex || 0;
	i = (i < 0) ? i + iz : i;
	for (; i < iz; ++i) {
		if (i in this && this[i] === search) {
			return i;
		}
	}
	return -1;
}
function arraylastindexof(search, fromIndex) {
	var iz = this.length, i = fromIndex;
	i = (i < 0) ? i + iz + 1 : iz;
	while (--i >= 0) {
		if (i in this && this[i] === search) {
			return i;
		}
	}
	return -1;
}
function arrayevery(evaluator, that) {
	for (var i = 0, iz = this.length; i < iz; ++i) {
		if (i in this && !evaluator.call(that, this[i], i, this)) {
			return false;
		}
	}
	return true;
}
function arraysome(evaluator, that) {
	for (var i = 0, iz = this.length; i < iz; ++i) {
		if (i in this && evaluator.call(that, this[i], i, this)) {
			return true;
		}
	}
	return false;
}
function arrayforeach(evaluator, that) {
	var i = 0, iz = this.length;
	if (that) {
		for (; i < iz; ++i) {
			i in this && evaluator.call(that, this[i], i, this);
		}
	} else {
		for (; i < iz; ++i) {
			i in this && evaluator(this[i], i, this);
		}
	}
}
function arraymap(evaluator, that) {
	for (var iz = this.length, rv = Array(iz), i = 0; i < iz; ++i) {
		i in this && (rv[i] = evaluator.call(that, this[i], i, this));
	}
	return rv;
}
function arrayfilter(evaluator, that) {
	for (var rv = [], ri = -1, v, i = 0, iz = this.length; i < iz; ++i) {
		i in this && evaluator.call(that, v = this[i], i, this)
				 && (rv[++ri] = v);
	}
	return rv;
}
function arrayreduce(evaluator, initialValue) {
	var z, f = 0, rv = initialValue === z ? z : (++f, initialValue),
		i = 0, iz = this.length;
	for (; i < iz; ++i) {
		i in this && (rv = f ? evaluator(rv, this[i], i, this) : (++f, this[i]));
	}
	if (!f) {
		throw new Error(arrayreduce._MSG);
	}
	return rv;
}
arrayreduce._MSG = "reduce of empty array with no initial value";
function arrayreduceright(evaluator, initialValue) {
	var z, f = 0, rv = initialValue === z ? z : (++f, initialValue),
		i = this.length;
	while (--i >= 0) {
		i in this && (rv = f ? evaluator(rv, this[i], i, this) : (++f, this[i]));
	}
	if (!f) {
		throw new Error(arrayreduce._MSG);
	}
	return rv;
}
function datetoisostring() {
	return uudate(this).ISO();
}
function numbertojson() {
	return this.toString();
}
function stringtrim() {
	return this.replace(uutrim._TRIM, "");
}
function stringtojson() {
	return _str2json(this);
}
function innertextgetter() {
	return this.textContent;
}
function innertextsetter(text) {
	while (this.hasChildNodes()) {
		this.removeChild(this.lastChild);
	}
	this.appendChild(doc.createTextNode(text));
}
function outerhtmlgetter() {
	var rv, that = this, p = that.parentNode,
		r = doc.createRange(), div = doc.createElement("div");
	p || doc.body.appendChild(that);
	r.selectNode(that);
	div.appendChild(r.cloneContents());
	rv = div.innerHTML;
	p || that.parentNode.removeChild(that);
	return rv;
}
function outerhtmlsetter(html) {
	var r = doc.createRange();
	r.setStartBefore(this);
	this.parentNode.replaceChild(r.createContextualFragment(html), this);
}
uuevent._LIST.forEach(function(eventType) {
	uu[eventType] = function bindEvent(node, fn) {
		return uuevent(node, eventType, fn);
	};
	uu["un" + eventType] = function unbindEvent(node) {
		return uuevent(node, eventType, 0, true);
	};
});
try {
	uu.ver.ie6 && doc.execCommand("BackgroundImageCache", false, true);
} catch(err) {}
function _ready() {
	if (!uuready.gone.blackout && !uuready.gone.dom++) {
		uulazyfire("boot");
		uuisfunction(win.xboot || 0) && win.xboot(uu);
	}
}
function _winload() {
	uuready.gone.win = 1;
	_ready();
	uuisfunction(win.xwin || 0) && win.xwin(uu);
	uulazyfire("canvas");
	uulazyfire("audio");
	uulazyfire("video");
}
function _domreadyie() {
	try {
		doc.firstChild.doScroll("up"), _ready();
	} catch(err) { setTimeout(_domreadyie, 64); }
}
uueventattach(win, "load", _winload);
uu.ie ? _domreadyie() : uueventattach(doc, "DOMContentLoaded", _ready);
function _winunload() {
	var nodeid, node, ary, i, v;
	for (nodeid in uunodeid._db) {
		try {
			node = uunodeid._db[nodeid];
			ary = node.attributes, i = -1;
			while ( (v = ary[++i]) ) {
				!v.name.indexOf("uu") && (node[v.name] = null);
			}
		} catch (err) {}
	}
	doc.html = null;
	doc.head = null;
	win.detachEvent("onload", _winload);
	win.detachEvent("onunload", _winunload);
}
uu.ie && win.attachEvent("onunload", _winunload);
uuready(function() {
	var nodeList = doc.html.getElementsByTagName("*"), v, i = -1,
		styles = uusplittohash((uu.ie ? "float,styleFloat,cssFloat,styleFloat"
									 : "float,cssFloat,styleFloat,cssFloat") +
				",pos,position,w,width,h,height,x,left,y,top,o,opacity," +
				"bg,background,bgcolor,backgroundColor,bgimg,backgroundImage," +
				"bgrpt,backgroundRepeat,bgpos,backgroundPosition");
	uumix(_camelhash(uufix._db, uu.webkit ? uustyle(doc.html)
										 : doc.html.style),
					 styles, uuattr._HASH);
	uunodeid(doc.html);
	while ( (v = nodeList[++i]) ) {
		v.nodeType === 1 && uunodeid(v);
	}
}, 2);
function _camelhash(rv, props) {
	function _camelize(m, c) {
		return c.toUpperCase();
	}
	function _decamelize(m, c, C) {
		return c + "-" + C.toLowerCase();
	}
	var k, v, CAMELIZE = /-([a-z])/g, DECAMELIZE = /([a-z])([A-Z])/g;
	for (k in props) {
		if (typeof props[k] === "string") {
			if (uu.webkit) {
				v = k = props.item(k);
				k.indexOf("-") >= 0 && (v = k.replace(CAMELIZE, _camelize));
				(k !== v) && (rv[k] = v);
			} else {
				v = ((uu.gecko && !k.indexOf("Moz")) ? "-moz" + k.slice(3) :
					 (uu.ie    && !k.indexOf("ms"))  ? "-ms"  + k.slice(2) :
					 (uu.opera && !k.indexOf("O"))   ? "-o"   + k.slice(1) : k).
					replace(DECAMELIZE, _decamelize);
				(k !== v) && (rv[v] = k);
			}
		}
	}
	return rv;
}
function _classNameMatcher(ary) {
	return RegExp("(?:^| )(" + ary.join("|") + ")(?:$|(?= ))", "g");
}
function _makeMapping(seed, s2n, n2s) {
	var i = 0, j, k = -1, v, ary = seed.split(""), iz = ary.length;
	for (; i < iz; ++i) {
		for (j = 0; j < iz; ++j) {
			v = ary[i] + ary[j];
			s2n[v] = ++k;
			n2s[k] = v;
		}
	}
}
function _version(libraryVersion) {
	function detectRenderingEngineVersion(userAgent) {
		var ver = ((/(?:rv\:|ari\/|sto\/)(\d+\.\d+(\.\d+)?)/.exec(userAgent)
						|| [,0])[1]).toString()
		return parseFloat(ver.replace(/[^\d\.]/g, "").
							 replace(/^(\d+\.\d+)(\.(\d+))?$/,"$1$3"));
	}
	function detectUserAgentVersion(userAgent) {
		var opera = window.opera || false;
		return opera ? +(opera.version().replace(/\d$/, ""))
					 : parseFloat((/(?:IE |fox\/|ome\/|ion\/)(\d+\.\d)/.
								 exec(userAgent) || [,0])[1]);
	}
	function detectFlashVersion(ie) {
		var rv = 0, obj, ver, m;
		try {
			obj = ie ? new ActiveXObject("ShockwaveFlash.ShockwaveFlash")
					 : navigator.plugins["Shockwave Flash"];
			ver = ie ? obj.GetVariable("$version").replace(/,/g, ".")
					 : obj.description;
			m = /\d+\.\d+/.exec(ver);
			rv = m ? parseFloat(m[0]) : 0;
		} catch(err) {}
		return rv < 7 ? 0 : rv;
	}
	function detectSilverlightVersion(ie) {
		var rv = 0, obj, check = 3;
		try {
			if (ie) {
				obj = new ActiveXObject("AgControl.AgControl");
				while (obj.IsVersionSupported(check + ".0")) {
					rv = check++;
				}
			} else {
				obj = navigator.plugins["Silverlight Plug-In"];
				rv = parseInt(/\d+\.\d+/.exec(obj.description)[0]);
			}
		} catch(err) {}
		return rv < 3 ? 0 : rv;
	}
	var rv = { library: libraryVersion },
		ie = !!doc.uniqueID, userAgent = navigator.userAgent;
	rv.render       = detectRenderingEngineVersion(userAgent);
	rv.browser      = detectUserAgentVersion(userAgent);
	rv.flash        = detectFlashVersion(ie);
	rv.silverlight  = detectSilverlightVersion(ie);
	rv.ie           = ie;
	rv.ie6          = ie && rv.browser === 6;
	rv.ie7          = ie && rv.browser === 7;
	rv.ie8          = ie && (doc.documentMode || 0) === 8;
	rv.ie9          = ie && (doc.documentMode || 0) === 9;
	rv.ie67         = rv.ie6 || rv.ie7;
	rv.ie678        = rv.ie6 || rv.ie7 || rv.ie8;
	rv.ie89         = rv.ie8 || rv.ie9;
	rv.opera        = !!(window.opera || false);
	rv.gecko        = userAgent.indexOf("Gecko/") > 0;
	rv.webkit       = userAgent.indexOf("WebKit") > 0;
	rv.chrome       = userAgent.indexOf("Chrome") > 0;
	rv.safari       = !rv.chrome && userAgent.indexOf("Safari") > 0;
	rv.iphone       = rv.webkit && /iPad|iPod|iPhone/.test(userAgent);
	rv.quirks       = (doc.compatMode || "") !== "CSS1Compat";
	rv.xml          = uunode("div").tagName === uunode("DIV").tagName;
	rv.win          = userAgent.indexOf("Win") > 0;
	rv.mac          = userAgent.indexOf("Mac") > 0;
	rv.unix         = /X11|Linux/.test(userAgent);
	rv.as3          = rv.flash >= 9;
	rv.advanced     = (ie        && rv.browser >= 9)   ||
					 (rv.gecko  && rv.render  >  1.9) ||
					 (rv.webkit && rv.render  >= 528) ||
					 (rv.opera  && rv.browser >= 10.5);
	rv.major        = (ie        && rv.browser >= 6)   ||
					 (rv.opera  && rv.browser >= 9.5) ||
					 (rv.gecko  && rv.render  >= 1.9) ||
					 (rv.webkit && rv.render  >  524);
	rv.jit          = rv.advanced;
	return rv;
}
})(window, document);

uu.ajax || (function(win, doc, uu) {
uu.mix(uu, {
	ajax: uu.mix(uuajax, {
		get: uuajaxget,
		post: uuajaxpost,
		sync: uu.require,
		ifmod: uuajaxifmod,
		queue: uuajaxqueue,
		create: uuajaxcreate,
		expire: uuajaxexpire
	}),
	jsonp: uu.mix(uujsonp, {
		queue: uujsonpqueue
	})
});
function uuajax(url, option, callback, ngCallback) {
	return _uuajax(url, option || {}, callback, ngCallback);
}
function _uuajax(url, option, callback, ngCallback, _fn2) {
	function _onReadyStateChange() {
		if (xhr.readyState !== 4) {
			return;
		}
		var status = xhr.status || 0,
			lastModified,
			result;
		if ((status >= 200 && status < 300)
			|| (!status && !url.indexOf("file:"))) {
			if (callback && !run++) {
				result = _createAjaxResultHash(true, status || 200);
				callback(result);
				_fn2 && _fn2(result);
			}
			if (option.ifmod) {
				lastModified = xhr.getResponseHeader("Last-Modified");
				if (lastModified) {
					_uuajax._cache[url] =
							uu.date(Date.parse(lastModified)).GMT();
				}
			}
		} else {
			_ngCallback(status || ((uu.opera && option.ifmod) ? 304 : 400));
		}
		_garbageCollection();
	}
	function _createAjaxResultHash(ok, status) {
		return {
			id:     option.id,
			ok:     ok,
			url:    url,
			xhr:    xhr,
			guid:   guid,
			status: status,
			isXMLContent:  function() {
				return /xml/i.test(this.xhr.getResponseHeader("Content-Type") || "");
			}
		};
	}
	function _ngCallback(status) {
		ngCallback && !run++ &&
			ngCallback(_createAjaxResultHash(false, status));
	}
	function _garbageCollection() {
		beforeUnload && uu.event.detach(win, "beforeunload", beforeUnload);
		xhr && (xhr.onreadystatechange = uu.nop, xhr = null);
	}
	function _watchdog() {
		_abort();
		_ngCallback(408);
		_garbageCollection();
	}
	function _abort() {
		try {
			xhr && xhr.abort();
		} catch(err) {}
	}
	var xhr = option.xhr || uuajaxcreate(),
		guid = uu.guid(),
		header = option.header || [],
		run = 0, v, i = -1, beforeUnload;
	url = toAbsoluteURL(url);
	if (option.nocache) {
		url += (url.indexOf("?") < 0 ? "?" :
				url.indexOf("&") < 0 ? ";" : "&") + "uuguid=" + +(new Date);
	}
	if (xhr) {
		try {
			uu.gecko && uu.event.attach(win, "beforeunload",
										beforeUnload = _abort);
			xhr.open(option.method || (option.data ? "POST" : "GET"), url, true);
			xhr.onreadystatechange = _onReadyStateChange;
			header.push("X-Requested-With", "XMLHttpRequest");
			if (option.ifmod && _uuajax._cache[url]) {
				header.push("If-Modified-Since", _uuajax._cache[url]);
			}
			if (option.data) {
				header.push("Content-Type", "application/x-www-form-urlencoded");
			}
			while ( (v = header[++i]) ) {
				xhr.setRequestHeader(v, header[++i]);
			}
			option.beforeCallback && option.beforeCallback(xhr);
			xhr.send(option.data || null);
			setTimeout(_watchdog, (option.timeout || 10) * 1000);
			return guid;
		} catch (err) {
			xhr = xhr || { responseText: "", responseXML: "", status: 400 };
		}
	}
	setTimeout(function() {
		_ngCallback(400);
		_garbageCollection();
	}, 0);
	return guid;
}
_uuajax._cache  = {};
function uuajaxget(url, option, callback, ngCallback) {
	return _uuajax(url, uu.arg(option, { data: null }), callback, ngCallback);
}
function uuajaxpost(url, data, option, callback, ngCallback) {
	return _uuajax(url, uu.arg(option, { data: data }), callback, ngCallback);
}
function uuajaxifmod(url, option, callback, ngCallback) {
	return _uuajax(url, uu.arg(option, { ifmod: 1 }), callback, ngCallback);
}
function uuajaxqueue(command, url, option, callback, lastCallback, ngCallback) {
	_uuajaxqueue(1, command, url, option, callback,
				 lastCallback || uu.nop, ngCallback || uu.nop, []);
}
function _uuajaxqueue(ajax, command, url, option,
					 callback, lastCallback, ngCallback, rv) {
	function _nextQueue(r) {
		_uuajaxqueue(ajax, command, url, option,
					 callback, lastCallback, ngCallback, rv.concat(r));
	}
	if (!command) {
		lastCallback(rv);
		return;
	}
	var cmd, commandArray = command.split(""), ary = [];
	command = "";
	while ( (cmd = commandArray.shift()) ) {
		ary.push(url.shift(),
				 uu.mix(option.shift() || {}, { id: cmd }),
				 callback.shift());
		if (commandArray.shift() === ">") {
			command = commandArray.join("");
			break;
		}
	}
	_uuajaxparallel(ajax, ary, _nextQueue, ngCallback);
}
function _uuajaxparallel(ajax, ary, lastCallback, ngCallback) {
	function _nextParallel(hash) {
		var idx = atom.indexOf(hash.guid);
		rv[idx] = hash;
		++n >= iz / 3 && !run++ && lastCallback(rv);
	}
	function _error(hash) {
		!run++ && ngCallback(hash);
	}
	var rv = [], atom = [], i = 0, iz = ary.length, n = 0, run = 0;
	for (; i < iz; i += 3) {
		atom.push((ajax ? _uuajax : _uujsonp)(ary[i], ary[i + 1],
											 ary[i + 2], _error, _nextParallel));
	}
}
function uuajaxcreate() {
	return win.ActiveXObject  ? new ActiveXObject("Microsoft.XMLHTTP") :
		 win.XMLHttpRequest ? new XMLHttpRequest() : null;
}
function uuajaxexpire() {
	_uuajax._cache = {};
}
function uujsonp(url, option, callback, ngCallback) {
	return _uujsonp(url, option || {}, callback, ngCallback);
}
uujsonp._jobdb = {};
function _uujsonp(url, option, callback, ngCallback, _fn2) {
	function _watchdog() {
		uujsonp._jobdb[guid]("", 408);
	}
	function _garbageCollection() {
		doc.head.removeChild(script);
		win[method] = null;
		delete uujsonp._jobdb[guid];
	}
	var guid = uu.guid(),
		timeout = option.timeout || 10,
		src = url,
		script = uu.node("script", {
			type:       "text/javascript",
			charset:    "utf-8",
			uujsonprun: 0
		}),
		method = option.method || "callback";
	if (/\=\?$/.test(src)) {
		src = uu.format(src, "?", method);
	}
	uujsonp._jobdb[guid] = method;
	win[method] = function(json, _status_) {
		if (!script.uujsonprun++) {
			if (json) {
				var result = {
					id:     option.id,
					ok:     true,
					url:    src,
					json:   json,
					guid:   guid,
					status: 200
				};
				callback && callback(result);
				_fn2 && _fn2(result);
			} else {
				ngCallback && ngCallback({
					id:     option.id,
					ok:     false,
					url:    src,
					json:   void 0,
					guid:   guid,
					status: _status_ || 404
				});
			}
			setTimeout(_garbageCollection, (timeout + 10) * 1000);
		}
	};
	doc.head.appendChild(script);
	script.setAttribute("src", src);
	setTimeout(_watchdog, timeout * 1000);
	return guid;
}
function uujsonpqueue(command, url, option,
					 callback, lastCallback, ngCallback) {
	_uuajaxqueue(0, command, url, option, callback,
				 lastCallback || uu.nop, ngCallback || uu.nop, []);
}
function toAbsoluteURL(url) {
	if (!toAbsoluteURL._ABSURL.test(url)) {
		var div = uu.node();
		div.innerHTML = '<a href="' + url + '" />';
		url = div.firstChild ? div.firstChild.href
							 : /href\="([^"]+)"/.exec(div.innerHTML)[1];
	}
	return url;
}
toAbsoluteURL._ABSURL = /^(?:file|https?):/;
})(window, document, uu);

uu.flash || (function(win, doc, uu) {
uu.mix(uu, {
	flash: uu.mix(uuflash, {
		send: uuflashsend,
		post: uuflashpost,
		alert: uuflashalert
	})
});
function uuflash(url, option) {
	option = uu.arg(option, {
		id:         "external" + uu.guid(),
		width:      "100%",
		height:     "100%",
		marker:     null,
		param:      []
	});
	if (option.param.indexOf("allowScriptAccess") <= 0) {
		option.param.push("allowScriptAccess", "always");
	}
	uu.ie && option.param.push("movie", url);
	if (!option.marker) {
		option.marker = uu.node.add();
	}
	var paramArray = [], i = 0, iz = option.param.length, html;
	for (; i < iz; i += 2) {
		paramArray.push(uu.format('<param name="?" value="?" />',
								 option.param[i], option.param[i + 1]));
	}
	html = uu.format('<object id="?" data="?" width="?" height="?" ?>?</object>',
				option.id,
				url,
				option.width,
				option.height,
				uu.ie ? 'classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"'
					 : 'type="application/x-shockwave-flash"',
				paramArray.join(""));
	uu.node.swap(uu.node.bulk(html), option.marker);
	return uu.id(option.id);
}
function uuflashpost(guid, msg, param) {
	uu.msg.post(guid, msg, param);
}
function uuflashsend(guid, msg, param) {
	return uu.msg.send(guid, msg, param);
}
function uuflashalert(msg, debug) {
	if (debug) {
		uu.config.debug && uu.puff(msg);
	} else {
		uu.puff(msg);
	}
}
})(window, document, uu);

uu.Class.Storage || (function(win, doc, uu) {
var _backendOrder = "LocalStorage,FlashStorage,IEStorage,CookieStorage,MemStorage";
uu.Class.singleton("Storage", {
	init:           init,
	nth:            nth,
	get:            get,
	set:            set,
	size:           size,
	pairs:          pairs,
	clear:          clear,
	remove:         remove,
	getAll:         getAll,
	saveToServer:   saveToServer,
	loadFromServer: loadFromServer,
	toString:       toString
});
uu.Class.Storage.saveToServer = function(backend, url, option, callback) {
	var json = uu.json(backend.getAll());
	uu.ajax.post(url, json, option, function(ajaxResultHash) {
		callback && callback(ajaxResultHash);
	}, function(ajaxResultHash) {
		callback && callback(ajaxResultHash);
	});
};
uu.Class.Storage.loadFromServer = function(backend, url, option, callback) {
	uu.jsonp(url, option, function(jsonpResultHash) {
		if (jsonpResultHash.ok) {
			var key, json = jsonpResultHash.json;
			for (key in json) {
				backend.set(key, json[key]);
			}
		}
		callback && callback(jsonpResultHash);
	}, function(jsonpResultHash) {
		callback && callback(jsonpResultHash);
	});
};
function init() {
	var that = this,
		requireDiskSpace = uu.config.storage;
	_backendOrder.split(",").some(function(backendName) {
		var Class = uu.Class[backendName];
		if (Class && Class.isReady()) {
			try {
				uu(backendName, function(backend) {
					var size = backend.size();
					if (requireDiskSpace && requireDiskSpace > size.max) {
						that.backend = uu("MemStorage");
					} else {
						that.backend = backend;
					}
					uu.ready.gone.storage = 1;
					if (uu.isFunction(win.xstorage)) {
						setTimeout(function() {
							win.xstorage(uu, that);
						}, 0);
					}
				});
			} catch(err) {
				return false;
			}
			return true;
		}
		return false;
	});
}
function nth(index) {
	return this.backend.nth(index) || "";
}
function get(key) {
	return this.backend.get(key) || "";
}
function set(key, value) {
	return this.backend.set(key, value);
}
function getAll() {
	return this.backend.getAll();
}
function size() {
	return this.backend.size();
}
function pairs() {
	return this.backend.pairs();
}
function clear() {
	this.backend.clear();
}
function remove(key) {
	this.backend.remove(key);
}
function saveToServer(url, option, callback) {
	uu.Class.Storage.saveToServer(this.backend, url, option, callback);
}
function loadFromServer(url, option, callback) {
	uu.Class.Storage.loadFromServer(this.backend, url, option, callback);
}
function toString() {
	return this.backend.toString();
}
uu.ready(function() {
	uu.Class["Storage"] && uu("Storage");
});
})(window, document, uu);

uu.Class.LocalStorage || (function(win, doc, uu) {
var _DISK_SPACE = uu.gecko      ? 5     * 1024 * 1024 - 260
				: uu.ver.iphone ? 2.5   * 1024 * 1024 - 260
				: uu.ver.safari ? 8     * 1024 * 1024
				: uu.ver.chrome ? 2.5   * 1024 * 1024 - 260
				: uu.webkit     ? 2.5   * 1024 * 1024 - 260
				: uu.opera      ? 1.875 * 1024 * 1024 - 128
				: uu.ie         ? 5     * 1000 * 1000
				: 0;
uu.Class.singleton("LocalStorage", {
	init:           init,
	nth:            nth,
	get:            get,
	set:            set,
	size:           size,
	pairs:          pairs,
	clear:          clear,
	remove:         remove,
	getAll:         getAll,
	saveToServer:   saveToServer,
	loadFromServer: loadFromServer,
	toString:       toString
});
uu.Class.LocalStorage.isReady = function() {
	return !!win.localStorage;
};
function init(callback) {
	this.storage = win.localStorage;
	callback && callback(this);
}
function nth(index) {
	return this.storage.key(index) || "";
}
function get(key) {
	return this.storage[key] || "";
}
function getAll() {
	var rv = {}, key, index = 0, iz = this.storage.length;
	for (; index < iz; ++index) {
		key = this.storage.key(index);
		rv[key] = this.storage.getItem(key);
	}
	return rv;
}
function set(key, value) {
	try {
		this.storage[key] = "";
		this.storage[key] = value;
	} catch(err) {
		return false;
	}
	return this.storage[key] === value;
}
function size() {
	var used = 0, i = 0, iz, remain;
	if (uu.ie && "remainingSpace" in this.storage) {
		remain = this.storage.remainingSpace;
		if (_DISK_SPACE < remain) {
			_DISK_SPACE = 5 * 1000 * 1000;
		}
		return { used: _DISK_SPACE - remain, max: _DISK_SPACE };
	}
	for (iz = this.storage.length; i < iz; ++i) {
		used += this.storage.getItem(this.storage.key(i)).length;
	}
	return { used: used, max: _DISK_SPACE };
}
function pairs() {
	return this.storage.length;
}
function clear() {
	this.storage.clear();
}
function remove(key) {
	this.storage.removeItem(key);
}
function saveToServer(url, option, callback) {
	uu.Class.Storage.saveToServer(this, url, option, callback);
}
function loadFromServer(url, option, callback) {
	uu.Class.Storage.loadFromServer(this, url, option, callback);
}
function toString() {
	return "LocalStorage";
}
})(window, document, uu);

uu.Class.FlashStorage || (function(win, doc, uu) {
var _SWF_PATH = uu.config.baseDir + "uu.storage.swf",
	_CALLBACK_ID = "externalflashstorage";
uu.Class.singleton("FlashStorage", {
	init:           init,
	nth:            nth,
	get:            get,
	set:            set,
	size:           size,
	pairs:          pairs,
	clear:          clear,
	remove:         remove,
	getAll:         getAll,
	saveToServer:   saveToServer,
	loadFromServer: loadFromServer,
	toString:       toString
});
uu.Class.FlashStorage.isReady = function() {
	return uu.ver.as3 && uu.require(_SWF_PATH).ok;
};
function init(callback) {
	var that = this;
	function flashStorageReadyCallback() {
		setTimeout(function() {
			uu.dmz[_CALLBACK_ID] = null;
			callback && callback(that);
		}, 0);
	}
	uu.dmz[_CALLBACK_ID] = flashStorageReadyCallback;
	this.storage = uu.flash(_SWF_PATH, {
						id: _CALLBACK_ID,
						width: 1,
						height: 1,
						param: [
						]
				 });
}
function nth(index) {
	return this.storage.ex_nth(index);
}
function get(key) {
	return this.storage.ex_get(key);
}
function getAll() {
	return this.storage.ex_getAll();
}
function set(key, value) {
	return this.storage.ex_set(key, value);
}
function size() {
	return this.storage.ex_size();
}
function pairs() {
	return this.storage.ex_pairs();
}
function clear() {
	this.storage.ex_clear();
}
function remove(key) {
	this.storage.ex_remove(key);
}
function saveToServer(url, option, callback) {
	uu.Class.Storage.saveToServer(this, url, option, callback);
}
function loadFromServer(url, option, callback) {
	uu.Class.Storage.loadFromServer(this, url, option, callback);
}
function toString() {
	return "FlashStorage";
}
})(window, document, uu);

uu.Class.IEStorage || (function(win, doc, uu) {
var _STORE_NAME     = "uustorage",
	_INDEX          = "uuindex",
	_PERSIST_DATE   = (new Date(2032, 1, 1)).toUTCString(),
	_DISK_SPACE     = 63 * 1024;
uu.Class.singleton("IEStorage", {
	init:           init,
	nth:            nth,
	get:            get,
	set:            set,
	size:           size,
	pairs:          pairs,
	clear:          clear,
	remove:         remove,
	getAll:         getAll,
	saveToServer:   saveToServer,
	loadFromServer: loadFromServer,
	toString:       toString
});
uu.Class.IEStorage.isReady = function() {
	return uu.ie;
};
function init(callback) {
	this.storage = uu.node.add("script", doc.head);
	this.storage.addBehavior("#default#userData");
	this.storage.expires = _PERSIST_DATE;
	callback && callback(this);
}
function nth(index) {
	this.storage.load(_STORE_NAME);
	return (this.storage.getAttribute(_INDEX) || "").split("\t")[index] || "";
}
function get(key) {
	this.storage.load(_STORE_NAME);
	return this.storage.getAttribute(key) || "";
}
function getAll() {
	this.storage.load(_STORE_NAME);
	var rv = {}, key, i = -1,
		indexes = (this.storage.getAttribute(_INDEX) || "").split("\t");
	while ( (key = indexes[++i]) ) {
		rv[key] = this.storage.getAttribute(key) || "";
	}
	return rv;
}
function set(key, value) {
	this.storage.load(_STORE_NAME);
	var index = this.storage.getAttribute(_INDEX);
	try {
		if (!index) {
			this.storage.setAttribute(_INDEX, key);
		} else if (("\t" + index + "\t").indexOf("\t" + key + "\t") < 0) {
			this.storage.setAttribute(_INDEX, index + "\t" + key);
		}
		this.storage.setAttribute(key, value);
		this.storage.save(_STORE_NAME);
	} catch(err) {
		return false;
	}
	return this.storage.getAttribute(key) === value;
}
function size() {
	this.storage.load(_STORE_NAME);
	var index = (this.storage.getAttribute(_INDEX) || ""),
		used = index.length,
		indexes = index.split("\t"), key, i = -1;
	while ( (key = indexes[++i]) ) {
		used += (this.storage.getAttribute(key) || "").length;
	}
	return { used: used, max: _DISK_SPACE };
}
function pairs() {
	this.storage.load(_STORE_NAME);
	return (this.storage.getAttribute(_INDEX) || "").split("\t").length;
}
function clear() {
	this.storage.load(_STORE_NAME);
	var indexes = (this.storage.getAttribute(_INDEX) || "").split("\t"),
		key, i = -1;
	while ( (key = indexes[++i]) ) {
		this.storage.removeAttribute(key);
	}
	this.storage.setAttribute(_INDEX, "");
	this.storage.save(_STORE_NAME);
}
function remove(key) {
	this.storage.load(_STORE_NAME);
	var index = (this.storage.getAttribute(_INDEX) || ""),
		tabIndex = "\t" + index + "\t",
		tabKey   = "\t" + key   + "\t";
	if (tabIndex.indexOf(tabKey) >= 0) {
		index = uu.trim(tabIndex.replace(new RegExp(tabKey), ""));
		this.storage.setAttribute(_INDEX, index);
		this.storage.removeAttribute(key);
		this.storage.save(_STORE_NAME);
	}
}
function saveToServer(url, option, callback) {
	uu.Class.Storage.saveToServer(this, url, option, callback);
}
function loadFromServer(url, option, callback) {
	uu.Class.Storage.loadFromServer(this, url, option, callback);
}
function toString() {
	return "IEStorage";
}
})(window, document, uu);

uu.Class.CookieStorage || (function(win, doc, uu) {
var _STORE_NAME     = "uustorage",
	_PERSIST_DATE   = (new Date(2032, 1, 1)).toUTCString(),
	_REMOVE_DATE    = (new Date(0)).toUTCString(),
	_DISK_SPACE     = 3800,
	_SECURE         = location.protocol === "https:" ? "; secure" : "";
uu.Class.singleton("CookieStorage", {
	init:           init,
	nth:            nth,
	get:            get,
	set:            set,
	size:           size,
	pairs:          pairs,
	clear:          clear,
	remove:         remove,
	getAll:         getAll,
	saveToServer:   saveToServer,
	loadFromServer: loadFromServer,
	toString:       toString,
	store:          store,
	retrieve:       retrieve
});
uu.Class.CookieStorage.isReady = function() {
	return !!navigator.cookieEnabled;
};
function init(callback) {
	this._shadowCookie = this.retrieve();
	callback && callback(this);
}
function nth(index) {
	return uu.hash.nth(this._shadowCookie, index)[0] || "";
}
function get(key) {
	return this._shadowCookie[key] || "";
}
function getAll() {
	return this._shadowCookie;
}
function set(key, value) {
	var before = doc.cookie.length;
	if (before > _DISK_SPACE) {
		return false;
	}
	if (before) {
		before += 2;
	}
	before += this.store(uu.hash(key, value), _PERSIST_DATE);
	if (before !== doc.cookie.length) {
		return false;
	}
	this._shadowCookie[key] = value;
	return true;
}
function size() {
	return { used: doc.cookie.length, max: _DISK_SPACE };
}
function pairs() {
	return uu.hash.size(this._shadowCookie);
}
function clear() {
	this.store(this._shadowCookie, _REMOVE_DATE);
	this._shadowCookie = {};
}
function remove(key) {
	this.store(uu.hash(key, ""), _REMOVE_DATE);
	delete this._shadowCookie[key];
}
function retrieve() {
	var rv = {}, i = -1, pairs, pair, kv, cut = _STORE_NAME.length;
	if (doc.cookie) {
		pairs = doc.cookie.split("; ");
		while ( (pair = pairs[++i]) ) {
			kv = pair.split("=");
			if (!kv[0].indexOf(_STORE_NAME)) {
				rv[kv[0].slice(cut)] = decodeURIComponent(kv[1] || "");
			}
		}
	}
	return rv;
}
function store(hash, date) {
	var rv = "", key;
	for (key in hash) {
		rv = _STORE_NAME + key + "=" + encodeURIComponent(hash[key]);
		doc.cookie = rv + "; expires=" + date + _SECURE;
	}
	return rv.length;
}
function saveToServer(url, option, callback) {
	uu.Class.Storage.saveToServer(this, url, option, callback);
}
function loadFromServer(url, option, callback) {
	uu.Class.Storage.loadFromServer(this, url, option, callback);
}
function toString() {
	return "CookieStorage";
}
})(window, document, uu);

uu.Class.MemStorage || (function(win, doc, uu) {
uu.Class.singleton("MemStorage", {
	init:           init,
	nth:            nth,
	get:            get,
	set:            set,
	size:           size,
	pairs:          pairs,
	clear:          clear,
	remove:         remove,
	getAll:         getAll,
	saveToServer:   saveToServer,
	loadFromServer: loadFromServer,
	toString:       toString
});
uu.Class.MemStorage.isReady = function() {
	return true;
};
function init(callback) {
	this.storage = {};
	callback && callback(this);
}
function nth(index) {
	return uu.hash.nth(this.storage, index)[0] || "";
}
function get(key) {
	return this.storage[key] || "";
}
function set(key, value) {
	this.storage[key] = value;
	return true;
}
function getAll() {
	return this.storage;
}
function size() {
	return { used: 0, max: Number.MAX_VALUE };
}
function pairs() {
	return uu.hash.size(this.storage);
}
function clear() {
	this.storage = {};
}
function remove(key) {
	delete this.storage[key];
}
function saveToServer(url, option, callback) {
	uu.Class.Storage.saveToServer(this, url, option, callback);
}
function loadFromServer(url, option, callback) {
	uu.Class.Storage.loadFromServer(this, url, option, callback);
}
function toString() {
	return "MemStorage";
}
})(window, document, uu);
uu.lazy.fire("init");

